cmapi.h

Go to the documentation of this file.

/*********************************************************************
 *
 *           Copyright (c) 2021 by Visuality Systems, Ltd.
 *
 *********************************************************************
 * FILE NAME     : $Workfile:$
 * ID            : $Header:$
 * REVISION      : $Revision:$
 *--------------------------------------------------------------------
 * DESCRIPTION   : Entire CM - Common library functionality
 *--------------------------------------------------------------------
 * MODULE        : NQ
 * DEPENDENCIES  :
 ********************************************************************/

#ifndef _CMAPI_H_
#define _CMAPI_H_

#include "syapi.h"          /* system-dependent */
#include <cmcommon.h>       /* basic types */
#include <cmparams.h>       /* parameters */
#include <cmutils.h>        /* more common functionality for all modules */
#include <cmlist.h>         /* linked list */
#include <cmmemory.h>       /* dynamic memory */
#include <cmselfip.h>       /* IP configuration */
#include <cmresolver.h>     /* name to IP resolver */
#include <cmthread.h>       /* thread management */
#ifdef UD_NQ_INCLUDECODEPAGE
#include <cmcp.h>           /* Code pages */
#endif /* UD_NQ_INCLUDECODEPAGE */
#include <cmunicod.h>       /* ANSI to UNICODE and v/v */
#include <cmstrparse.h>     /* string parser */
#include <cmstring.h>       /* mapping of string manipulation */
#include <cmnbapi.h>        /* NetBIOS */
#include <cmfsapi.h>        /* CIFS */
#include <cmrpcdef.h>       /* DCERPC */
#include <cmsdescr.h>       /* Security Descriptors */
#include <cmvalida.h>       /* Validation of cross-dependencies */
#include <cmtrace.h>        /* traces */
#include <cmbufman.h>
#ifdef UD_NQ_INCLUDESMBCAPTURE
#include <cmcapture.h>
#endif /* UD_NQ_INCLUDESMBCAPTURE */
#include <udconfig.h>


NQ_STATUS cmInit(NQ_UINT32 component);

void cmExit(NQ_UINT32 component);

#define NQ_CLIENT                   0x1 
#define NQ_SERVER                   0x2 
#define NQ_NDDAEMON                 0x4 
#define NQ_RESOLVER_IPV4            4   
#define NQ_RESOLVER_IPV6            6   
#define NQ_RESOLVER_NONE            0   
#define NQ_RESOLVER_DNS             1   
#define NQ_RESOLVER_NETBIOS         2   
#define NQ_RESOLVER_EXTERNAL_METHOD 5   
#define NQ_RESOLVER_DNS_DC          8   
#define NQ_RESOLVER_NETBIOS_DC      10  
#define NQ_RESOLVER_WSD             12  
typedef struct
{
    void        **items;            /* a cyclic sorted array of pointers to the memoryPool nodes */
    CMList      memoryPool;         /* A list of available unused memory blocks */
    NQ_UINT     currentPosition;    /* holds the current position of the next available memory block in the items array */
    NQ_UINT     numberOfItems;      /* number of current items in the items array */
    NQ_UINT32   divider;            /* when a new memory block has to be stored in the items array we need to use a formula to keep it sorted.
                                       The formula is dependent on a divider, we want to use the same divider for all the items calculations */
    void        *context;           /* a context pointer */
} CMLinkedListArray;

#define CM_PRODUCT_STRING_LEN 20

/* This struct represents the current product information */
typedef struct
{
    NQ_CHAR     productName[CM_PRODUCT_STRING_LEN];    /* The product name */
    NQ_CHAR     productType[CM_PRODUCT_STRING_LEN];    /* Client Standalone / Client Corporate / Server Standalone / Server Corporate */
    NQ_CHAR     version[CM_PRODUCT_STRING_LEN];        /* The current product version */
    NQ_UINT32   checksum;
} CMProductInfo;

typedef struct
{
    NQ_INT  id;                                                                                 
    NQ_INT  (*toAnsi)   ( NQ_CHAR* outStr,  NQ_UINT outLength, const NQ_WCHAR* inWStr, NQ_UINT inLength);  
    NQ_INT  (*toUnicode)( NQ_WCHAR* outWStr, NQ_UINT outLength, const NQ_CHAR* inStr, NQ_UINT inLength);   
    NQ_INT  (*toUpper)  ( NQ_CHAR* dst,  const NQ_CHAR* src);                                        
    void    (*ansiToFs) ( NQ_CHAR* str, NQ_INT size, const NQ_BYTE* firstIllegalChar, const NQ_BYTE* anyIllegalChar, NQ_INT numOfFirstIllChars, NQ_INT numOfAnyIllChars);
    void    (*fsToAnsi) ( NQ_CHAR* str, NQ_INT size, const NQ_BYTE* firstIllegalChar, const NQ_BYTE* anyIllegalChar, NQ_INT numOfFirstIllChars, NQ_INT numOfAnyIllChars);

    const NQ_WCHAR* a2uTab;                                                                     
}
CMCodepage;

typedef struct
{

    NQ_INT activationPriority;  
    NQ_UINT32 timeout; 
    NQ_IPADDRESS *serverIP;  
    NQ_STATUS (* requestByName)(SYSocketHandle socket, const NQ_WCHAR * name, void * context,
                                                             const NQ_IPADDRESS * serverIp, NQ_COUNT * numOfSentRequests);  
    NQ_STATUS (* responseByName)(SYSocketHandle socket, NQ_IPADDRESS ** pAddressArray, NQ_INT * numIps, void ** pContext);  
    NQ_STATUS (* requestByIp)(SYSocketHandle socket, const NQ_IPADDRESS * ip, void * context,
                                                             const NQ_IPADDRESS * serverIp, NQ_COUNT * numOfSentRequests);  
    NQ_STATUS (* responseByIp)(SYSocketHandle socket, const NQ_WCHAR ** pName, void ** pContext);   
}
CMResolverRegisteredMethodDescription;

/* function prototypes */

NQ_BOOL cmCodepageAdd(const CMCodepage * codePage);
 
NQ_BOOL cmCodepageRemove(const CMCodepage * codePage);

void cmWideCharToMultiByte(NQ_CHAR *strMultiByte, const NQ_WCHAR* strWideChar);

void cmMultiByteToWideChar(NQ_WCHAR* strWideChar, const NQ_CHAR *strMultiByte);

typedef void (* CMAbstractHasher)(const NQ_BYTE * dataIn, NQ_BYTE * dataOut, NQ_COUNT length);

typedef void (* CMAbstractCipher)(const CMBlob * key, const CMBlob * key1, const CMIOBlob dataFragments[], NQ_COUNT numFragments, NQ_BYTE * buffer, NQ_COUNT bufferSize);

typedef void (* CMAbstractIOCipher)(const CMBlob * key, const CMBlob * key1, const CMIOBlob dataFragments[], NQ_COUNT numFragments, NQ_BYTE * buffer, NQ_COUNT bufferSize);

typedef void (* CMAbstractHasher512)(const CMBlob * key, const CMBlob * key1, const CMIOBlob dataFragments[], NQ_COUNT numFragments, NQ_IOBufPos buffer, NQ_COUNT bufferSize, NQ_BYTE *ctxBuff);

typedef void (* CMAbstractCcmEncryption)(const CMBlob * key, const CMBlob * key1, const CMIOBlob * prefix, CMIOBlob * message, NQ_BYTE * auth);

typedef NQ_BOOL (* CMAbstractCcmDecryption)(const CMBlob * key, const CMBlob * key1, const CMIOBlob * prefix, CMIOBlob * message, const NQ_BYTE * auth);


typedef void (* CMAbstractGcmEncryption)(const CMBlob *key, const CMBlob *key1, const CMIOBlob *prefix, CMIOBlob *message, NQ_BYTE *auth, NQ_BYTE *keyBuffer, NQ_BYTE *encMsgBuffer);

typedef NQ_BOOL (* CMAbstractGcmDecryption)(const CMBlob * key, const CMBlob *key1, const CMIOBlob *prefix, CMIOBlob *message, const NQ_BYTE *auth, NQ_BYTE *keyBuffer, NQ_BYTE *msgBuffer);

typedef struct
{
    CMAbstractHasher md4;           
    CMAbstractCipher md5;           
    CMAbstractCipher hmacmd5;       
    CMAbstractIOCipher sha256;      
    CMAbstractIOCipher aes128cmac;  
    CMAbstractHasher512 sha512;     
    CMAbstractCcmEncryption aes128ccmEncryption;    
    CMAbstractCcmDecryption aes128ccmDecryption;    
    CMAbstractGcmEncryption aes128gcmEncryption;    
    CMAbstractGcmDecryption aes128gcmDecryption;    
} 
CMCrypterList;

void cmSetExternalCrypters(const CMCrypterList * crypters);

void cmResetExternalCrypters(void);

typedef NQ_INT (*CMResolverNameToIpA)(const NQ_CHAR * name, void * ip, NQ_COUNT index);

typedef NQ_INT (*CMResolverNameToIp)(const NQ_WCHAR * name, void * ip,  NQ_COUNT index);

typedef NQ_BOOL (*CMResolverIpToNameA)(NQ_CHAR * name, const void * ip, NQ_INT ipType);

typedef NQ_BOOL (*CMResolverIpToName)(NQ_WCHAR * name, const void * ip, NQ_INT ipType);

void cmResolverSetExternalA(CMResolverNameToIpA nameToIp, CMResolverIpToNameA ipToName);

void cmResolverSetExternal(CMResolverNameToIp nameToIp, CMResolverIpToName ipToName);

const NQ_WCHAR * cmResolverGetHostName(const NQ_IPADDRESS * ip);

const NQ_IPADDRESS * cmResolverGetHostIps(const NQ_WCHAR * dnsList, const NQ_WCHAR * host, NQ_INT * numIps);

const NQ_WCHAR * cmResolverGetDCName(const NQ_WCHAR * domain, const NQ_WCHAR * dnsList, NQ_INT * numDCs);

void cmResolverEnableMethod(NQ_INT type, NQ_BOOL unicast, NQ_BOOL multicast);

NQ_BOOL cmResolverRegisterExternalMethod(const CMResolverRegisteredMethodDescription * pMethod);

NQ_BOOL cmResolverUpdateExternalMethodsPriority(NQ_INT requiredPriority);

void cmDnsSetServersA(const NQ_CHAR * servers);

void cmDnsSetServers(const NQ_WCHAR * servers);

NQ_IPADDRESS * cmDnsGetServer(NQ_COUNT dnsID);

NQ_COUNT cmDnsGetNumDnsServers(void);

void cmNetBiosSetWinsA(const NQ_CHAR * servers);

void cmNetBiosSetWins(const NQ_WCHAR * servers);

NQ_IPADDRESS4  cmNetBiosGetWins(NQ_COUNT winsID);

NQ_COUNT cmNetBiosGetNumWinsServers(void);

NQ_STATUS cmDnsSetDomainA(const NQ_CHAR * domainName);

NQ_STATUS cmDnsSetDomain(const NQ_WCHAR * domainName);

NQ_STATUS cmNetBiosNameReload(void);

CMProductInfo * cmGetCurrentProductInformation(void);

#endif  /* _CMAPI_H_ */